namespace ext.dd
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// DragDropMgr is a singleton that tracks the element interaction for
	/// all DragDrop items in the window. Generally, you will not call
	/// this class directly, but it does have helper methods that could
	/// be useful in your DragDrop implementations.
	/// </summary>
	/// <definedin>src\dd\DDCore.js</definedin>
	/// <definedin>src\dd\DDCore.js</definedin>
	/// <definedin>src\dd\DDCore.js</definedin>
	[ScriptName("DragDropMgr")]
	[ScriptNamespace("Ext.dd")]
	[Imported()]
	public partial class DragDropMgr
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		internal DragDropMgr()
		{
		}
		#endregion
		
		#region Properties
		/// <summary>
		/// Flag to determine if we should prevent the default behavior of the
		/// events we define. By default this is true, but this can be set to
		/// false if you need the default behavior (not recommended)
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("preventDefault")]
		[IntrinsicProperty()]
		public static bool PreventDefault
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// Flag to determine if we should stop the propagation of the events
		/// we generate. This is true by default but you may want to set it to
		/// false if the html element contains other features that require the
		/// mouse click.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("stopPropagation")]
		[IntrinsicProperty()]
		public static bool StopPropagation
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// In point mode, drag and drop interaction is defined by the
		/// location of the cursor during the drag/drop
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("POINT")]
		[IntrinsicProperty()]
		public static int POINT
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>
		/// In intersect mode, drag and drop interaction is defined by the
		/// overlap of two or more drag and drop objects.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("INTERSECT")]
		[IntrinsicProperty()]
		public static int INTERSECT
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
		}
		
		/// <summary>The current drag and drop mode. Default: POINT</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("mode")]
		[IntrinsicProperty()]
		public static int Mode
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// Set useCache to false if you want to force object the lookup of each
		/// drag and drop linked element constantly during a drag.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("useCache")]
		[IntrinsicProperty()]
		public static bool UseCache
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// The number of pixels that the mouse needs to move after the
		/// mousedown before the drag is initiated. Default=3;
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("clickPixelThresh")]
		[IntrinsicProperty()]
		public static int ClickPixelThresh
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>
		/// The number of milliseconds after the mousedown event to initiate the
		/// drag if we don&apos;t get a mouseup event. Default=350
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("clickTimeThresh")]
		[IntrinsicProperty()]
		public static int ClickTimeThresh
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>Lock all drag and drop functionality</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("lock")]
		public static void Lock()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Unlock all drag and drop functionality</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("unlock")]
		public static void Unlock()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Is drag and drop locked?</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <returns>True if drag and drop is locked, false otherwise.</returns>
		[ScriptName("isLocked")]
		public static bool IsLocked()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Each DragDrop instance must be registered with the DragDropMgr.
		/// This is executed in DragDrop.init()
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="oDD">the DragDrop object to register</param>
		/// <param name="sGroup">the name of the group this element belongs to</param>
		[ScriptName("regDragDrop")]
		public static void RegDragDrop(ext.dd.DragDrop oDD, string sGroup)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Each DragDrop handle element must be registered. This is done
		/// automatically when executing DragDrop.setHandleElId()
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="sDDId">the DragDrop id this element is a handle for</param>
		/// <param name="sHandleId">
		/// the id of the element that is the drag
		/// handle
		/// </param>
		[ScriptName("regHandle")]
		public static void RegHandle(string sDDId, string sHandleId)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Utility function to determine if a given element has been
		/// registered as a drag drop item.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">the element id to check</param>
		/// <returns>
		/// true if this element is a DragDrop item,
		/// false otherwise
		/// </returns>
		[ScriptName("isDragDrop")]
		public static bool IsDragDrop(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns the drag and drop instances that are in all groups the
		/// passed in instance belongs to.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="p_oDD">the obj to get related data for</param>
		/// <param name="bTargetsOnly">if true, only return targetable objs</param>
		/// <returns>the related instances</returns>
		[ScriptName("getRelated")]
		public static ext.dd.DragDrop[] GetRelated(ext.dd.DragDrop p_oDD, bool bTargetsOnly)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns true if the specified dd target is a legal target for
		/// the specifice drag obj
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="oDD">the drag obj</param>
		/// <param name="oTargetDD">the target</param>
		/// <returns>
		/// true if the target is a legal target for the
		/// dd obj
		/// </returns>
		[ScriptName("isLegalTarget")]
		public static bool IsLegalTarget(ext.dd.DragDrop oDD, ext.dd.DragDrop oTargetDD)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// My goal is to be able to transparently determine if an object is
		/// typeof DragDrop, and the exact subclass of DragDrop. typeof
		/// returns &quot;object&quot;, oDD.constructor.toString() always returns
		/// &quot;DragDrop&quot; and not the name of the subclass. So for now it just
		/// evaluates a well-known variable in DragDrop.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="the">object to evaluate</param>
		/// <returns>true if typeof oDD = DragDrop</returns>
		[ScriptName("isTypeOfDD")]
		public static bool IsTypeOfDD(object the)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Utility function to determine if a given element has been
		/// registered as a drag drop handle for the given Drag Drop object.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">the element id to check</param>
		/// <returns>
		/// true if this element is a DragDrop handle, false
		/// otherwise
		/// </returns>
		[ScriptName("isHandle")]
		public static bool IsHandle(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the DragDrop instance for a given id</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="id">the id of the DragDrop object</param>
		/// <returns>the drag drop object, null if it is not found</returns>
		[ScriptName("getDDById")]
		public static ext.dd.DragDrop GetDDById(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Fired when either the drag pixel threshol or the mousedown hold
		/// time threshold has been met.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="x">the X position of the original mousedown</param>
		/// <param name="y">the Y position of the original mousedown</param>
		[ScriptName("startDrag")]
		public static void StartDrag(int x, int y)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Utility to stop event propagation and event default, if these
		/// features are turned on.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="e">the event as returned by this.getEvent()</param>
		[ScriptName("stopEvent")]
		public static void StopEvent(System.Html.ElementEvent e)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Helper function for getting the best match from the list of drag
		/// and drop objects returned by the drag and drop events when we are
		/// in INTERSECT mode. It returns either the first object that the
		/// cursor is over, or the object that has the greatest overlap with
		/// the dragged element.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="dds">
		/// The array of drag and drop objects
		/// targeted
		/// </param>
		/// <returns>The best single match</returns>
		[ScriptName("getBestMatch")]
		public static ext.dd.DragDrop GetBestMatch(ext.dd.DragDrop[] dds)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Refreshes the cache of the top-left and bottom-right points of the
		/// drag and drop objects in the specified group(s). This is in the
		/// format that is stored in the drag and drop instance, so typical
		/// usage is:
		///
		/// Ext.dd.DragDropMgr.refreshCache(ddinstance.groups);
		///
		/// Alternatively:
		///
		/// Ext.dd.DragDropMgr.refreshCache({group1:true, group2:true});
		/// </summary>
		/// <htmlSummary>
		/// Refreshes the cache of the top-left and bottom-right points of the
		/// drag and drop objects in the specified group(s). This is in the
		/// format that is stored in the drag and drop instance, so typical
		/// usage is:
		/// &lt;code&gt;
		/// Ext.dd.DragDropMgr.refreshCache(ddinstance.groups);
		/// &lt;/code&gt;
		/// Alternatively:
		/// &lt;code&gt;
		/// Ext.dd.DragDropMgr.refreshCache({group1:true, group2:true});
		/// &lt;/code&gt;
		/// </htmlSummary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="groups">an associative array of groups to refresh</param>
		[ScriptName("refreshCache")]
		public static void RefreshCache(object groups)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// This checks to make sure an element exists and is in the DOM. The
		/// main purpose is to handle cases where innerHTML is used to remove
		/// drag and drop objects from the DOM. IE provides an &apos;unspecified
		/// error&apos; when trying to access the offsetParent of such an element
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="el">the element to check</param>
		/// <returns>true if the element looks usable</returns>
		[ScriptName("verifyEl")]
		public static bool VerifyEl(System.Html.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns a Region object containing the drag and drop element&apos;s position
		/// and size, including the padding configured for it
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="oDD">
		/// the drag and drop object to get the
		/// location for
		/// </param>
		/// <returns>
		/// a Region object representing the total area
		/// the element occupies, including any padding
		/// the instance is configured for.
		/// </returns>
		[ScriptName("getLocation")]
		public static ext.lib.Region GetLocation(ext.dd.DragDrop oDD)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the actual DOM element</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="id">the id of the elment to get</param>
		/// <returns>The element</returns>
		[ScriptName("getElement")]
		public static object GetElement(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Returns the style property for the DOM element (i.e.,
		/// document.getElById(id).style)
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="id">the id of the elment to get</param>
		/// <returns>The style property of the element</returns>
		[ScriptName("getCss")]
		public static object GetCss(string id)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the X position of an html element</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="el">element for which to get the position</param>
		/// <returns>the X coordinate</returns>
		[ScriptName("getPosX")]
		public static int GetPosX(System.Html.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the Y position of an html element</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="el">element for which to get the position</param>
		/// <returns>the Y coordinate</returns>
		[ScriptName("getPosY")]
		public static int GetPosY(System.Html.Element el)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Swap two nodes. In IE, we use the native method, for others we
		/// emulate the IE behavior
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="n1">first node to swap</param>
		/// <param name="n2">other node to swap</param>
		[ScriptName("swapNode")]
		public static void SwapNode(object n1, object n2)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the specified element style property</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <deprecated>Deprecated</deprecated>
		/// <param name="el">the element</param>
		/// <param name="styleProp">the style property</param>
		/// <returns>The value of the style property</returns>
		[ScriptName("getStyle")]
		public static string GetStyle(System.Html.Element el, string styleProp)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the scrollTop</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <returns>the document&apos;s scrollTop</returns>
		[ScriptName("getScrollTop")]
		public static int GetScrollTop()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Gets the scrollLeft</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <returns>the document&apos;s scrollTop</returns>
		[ScriptName("getScrollLeft")]
		public static int GetScrollLeft()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Sets the x/y position of an element to the location of the
		/// target element.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="moveEl">The element to move</param>
		/// <param name="targetEl">The position reference element</param>
		[ScriptName("moveToEl")]
		public static void MoveToEl(System.Html.Element moveEl, System.Html.Element targetEl)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Numeric array sort function</summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		[ScriptName("numericSort")]
		public static void NumericSort()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Recursively searches the immediate parent and all child nodes for
		/// the handle element in order to determine wheter or not it was
		/// clicked.
		/// </summary>
		/// <definedin>src\dd\DDCore.js</definedin>
		/// <param name="node">html element to inspect</param>
		[ScriptName("handleWasClicked")]
		public static void HandleWasClicked(object node)
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
	}
}
